const express = require('express');
const path = require('path');
const fs = require('fs');

// 安全地获取 Electron app 对象
let electronApp = null;
try {
  const { app } = require('electron');
  electronApp = app;
} catch (error) {
  console.log('Electron app 不可用，使用开发模式');
}

const app = express();
const PORT = 3000;

// 中间件设置
app.use(express.json({ limit: '50mb' })); // 支持大文件上传
app.use(express.urlencoded({ extended: true, limit: '50mb' }));

// 添加CORS支持
app.use((req, res, next) => {
  res.header('Access-Control-Allow-Origin', '*');
  res.header('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
  res.header('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept, Authorization');
  
  if (req.method === 'OPTIONS') {
    res.sendStatus(200);
  } else {
    next();
  }
});

// 设置静态文件目录为public文件夹
// 在打包后的环境中，public文件夹位于app.asar中
const publicPath = (electronApp && electronApp.isPackaged) 
  ? path.join(electronApp.getAppPath(), 'public')
  : path.join(__dirname, 'public');

app.use(express.static(publicPath));

// 根路径重定向到index.html
app.get('/', (req, res) => {
  const indexPath = (electronApp && electronApp.isPackaged) 
    ? path.join(electronApp.getAppPath(), 'public', 'index.html')
    : path.join(__dirname, 'public', 'index.html');
  res.sendFile(indexPath);
});

// 测试接口
app.get('/api/test', (req, res) => {
  res.json({
    success: true,
    message: '服务器正常运行',
    timestamp: new Date().toISOString()
  });
});

// POST接口：接收渲染数据
app.post('/api/render', (req, res) => {
  try {
    // console.log('收到渲染请求:', req.body);
    const { key, name, list } = req.body;
    
    // 验证必需参数
    if (!key || !name || !list || !Array.isArray(list) || list.length !== 6) {
      return res.status(400).json({
        success: false,
        message: '参数错误：需要key、name和包含6张图片的list数组'
      });
    }
    
    // 创建renderResult目录（如果不存在）
    // 始终使用exe所在目录，确保文件输出位置一致
    let renderResultDir;
    if (electronApp && electronApp.isPackaged) {
      // 打包后：优先使用exe所在目录，如果无法写入则使用用户数据目录
      const exeDir = path.join(path.dirname(process.execPath), 'renderResult');
      const userDataDir = path.join(electronApp.getPath('userData'), 'renderResult');
      
      try {
        // 尝试在exe目录创建文件夹
        if (!fs.existsSync(exeDir)) {
          fs.mkdirSync(exeDir, { recursive: true });
        }
        renderResultDir = exeDir;
        console.log('使用exe所在目录:', renderResultDir);
      } catch (error) {
        // 如果exe目录无法写入，回退到用户数据目录
        renderResultDir = userDataDir;
        console.log('exe目录无法写入，使用用户数据目录:', renderResultDir);
      }
    } else {
      // 开发模式：使用项目目录
      renderResultDir = path.join(__dirname, 'renderResult');
    }
    
    console.log('最终renderResult目录路径:', renderResultDir);
    console.log('是否为打包模式:', electronApp && electronApp.isPackaged);
    if (electronApp && electronApp.isPackaged) {
      console.log('exe路径:', process.execPath);
      console.log('exe所在目录:', path.dirname(process.execPath));
      console.log('用户数据目录:', electronApp.getPath('userData'));
    }
    if (!fs.existsSync(renderResultDir)) {
      fs.mkdirSync(renderResultDir, { recursive: true });
    }
    
    // 创建以key命名的子文件夹
    const keyDir = path.join(renderResultDir, key);
    if (!fs.existsSync(keyDir)) {
      fs.mkdirSync(keyDir, { recursive: true });
    }
    
    // 保存6张图片
    const faceNames = ['pano_r', 'pano_l', 'pano_u', 'pano_d', 'pano_b', 'pano_f'];
    const savedFiles = [];
    
    list.forEach((base64Data, index) => {
      try {
        // 验证base64数据格式
        if (!base64Data || typeof base64Data !== 'string' || !base64Data.startsWith('data:image/')) {
          throw new Error(`第${index + 1}张图片数据格式错误`);
        }
        
        // 提取base64数据（去掉data:image/png;base64,前缀）
        const base64String = base64Data.split(',')[1];
        if (!base64String) {
          throw new Error(`第${index + 1}张图片base64数据无效`);
        }
        
        // 保存文件
        const fileName = `${faceNames[index]}.png`;
        const filePath = path.join(keyDir, fileName);
        const buffer = Buffer.from(base64String, 'base64');
        
        fs.writeFileSync(filePath, buffer);
        savedFiles.push(fileName);
        
      } catch (error) {
        throw error;
      }
    });
    
    // 创建位置信息文件
    const positionInfo = {
      key: key,
      name: name,
      timestamp: new Date().toISOString(),
      files: savedFiles,
      faceNames: faceNames
    };
    
    const infoFilePath = path.join(keyDir, 'position_info.json');
    fs.writeFileSync(infoFilePath, JSON.stringify(positionInfo, null, 2));
    
    
    res.json({
      success: true,
      message: '渲染数据保存成功',
      data: {
        key: key,
        name: name,
        savedFiles: savedFiles,
        directory: keyDir
      }
    });
    
  } catch (error) {
    console.error('处理渲染请求失败:', error);
    res.status(500).json({
      success: false,
      message: '服务器内部错误: ' + error.message
    });
  }
});

// 添加调试中间件
app.use((req, res, next) => {
  next();
});

// 添加错误处理中间件
app.use((err, req, res, next) => {
  console.error('服务器错误:', err);
  res.status(500).json({
    success: false,
    message: '服务器内部错误: ' + err.message
  });
});

// 启动服务器
app.listen(PORT, () => {
  console.log(`服务器运行在 http://localhost:${PORT}`);
  console.log(`访问 http://localhost:${PORT} 查看应用`);
  console.log(`渲染API接口: POST http://localhost:${PORT}/api/render`);
  console.log('服务器已启动，等待请求...');
});

module.exports = app;
